import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author 35326
 * 2021/3/25 21:10
 * 学习Stream的使用
 */
public class StreamTest {
	@Test
	/**
	 *
	 */
	public void testStreamCreate(){
		//1.通过集合
		List<Integer> list =
				new ArrayList<Integer>(){{add(1);add(2);}};
		Stream<Integer> stream1 = list.stream();
		Stream<Integer> integerStream1 = list.parallelStream();

		//2.通过数组
		IntStream stream = Arrays.stream(new int[]{1, 2, 3});
		//3.通过Stream.of()方法
		Stream<Integer> integerStream = Stream.of(1, 2, 1);

		//4.创建无限流
		 Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
		 Stream.generate(Math::random).limit(10).forEach(System.out::println);
	}

	@Test
	/**
	 * Stream的中间操作-之筛选与切片
	 */
	public void testOp(){
		//1- 筛选与切片
		//filter(Predicate p)-接收Lambda表达式，从流中排队某些元素
		IntStream stream = Arrays.stream(new int[]{1, 2, 3});
		stream.filter((t)->{return t%2!=0;}).forEach(System.out::println);
		//2-截断流，使其元素的数量不超过给定数量
		//limit(n)
		IntStream stream1 = Arrays.stream(new int[]{1, 2, 3});
		stream1.limit(3).forEach(System.out::println);
		//3-skip(n):跳过元素，返回一个扔掉了前n个元素的流。若流中的数据不足n个，则返回一个空流.
		//4-distinct():筛选。通过流所生成元素的hashCode()与equals()方法去重
	}
	@Test
	/**
	 * 中间操作之二---映射
	 */
	public void testOp2(){
		//map(Function f)-接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会应用到每个元素上
		List<String> strings = Arrays.asList("aa", "cc", "bb", "dd");
		strings.stream().map(String::toUpperCase).forEach(System.out::println);
		//flatmap(Function f):接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的
		//流连成一个流

	}

	@Test
	/**
	 * 中间操作之三————排序
	 */
	 public void testOp3(){
	      //sorted()-自然排序
		//sorted(Comparator com)--定制排序
	 }

	/**
	 * 终止操作之一：  匹配与查找
	 */
	@Test
	public void testResult(){
		/**
		 * allMatch(Predicate p)--检查是否匹配所有元素
		 * anyMatch(Predicate p)__检查是否至少匹配一个元素
		 * noneMatch(Predicate p)--检查是否没有匹配的元素
		 * findFirst()--返回第一个元素
		 * findAny()--返回当前流中的任意元素
		 * count()--返回流中的元素的总个数
		 * max(Comparator c)__返回流中的最大值
		 * min(Comparator c)--返回流中的最小值
		 * forEach(Consumer c)--内部迭代
 		 */

		/**
		 * 2-归约
		 * reduce(T identity,BinaryOperator b)--可以将流中的元素反复结合起来，得到一个值
		 * reduce(BinaryOperator p)--可以将流中的元素反复结合起来，得到一个值
		 */

		/**
		 * 3-收集
		 * collect(Collector c)--将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。
		 *
		 */
	}
}
